package com.xcj.springai.controller;


import com.xcj.springai.config.Agent;
import com.xcj.springai.dto.ConversationDto;
import com.xcj.springai.vo.ChatResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import reactor.core.publisher.Flux;

import java.io.IOException;
import java.util.Optional;
import java.util.Set;

@RequiredArgsConstructor
@RestController
@RequestMapping("/ai")
public class ChatController {

    private final Agent model;
    @PostMapping(value = "/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<Object> chat(@RequestBody ConversationDto dto) {
        return model.doChatByStreamByUserId(dto)
                .filter(chunk -> chunk.getResult().getOutput().getText() != null)
                .mapNotNull(chunk -> {
                    String text = chunk.getResult().getOutput().getText();
                    if (chunk.hasFinishReasons(Set.of("returnDirect"))) {
                        return text;
                    } else if (chunk.hasFinishReasons(Set.of("stop"))) {
                        return ChatResponse.builder().dt(text).done(true).build();
                    } else {
                        return ChatResponse.builder().dt(text).build();
                    }
                });
    }





//    @PostMapping(value = "/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE){
//    public SseEmitter chat(@RequestBody ConversationDto conversation) {
//        SseEmitter emitter = new SseEmitter(180000L);
//        Flux<org.springframework.ai.chat.model.ChatResponse> chatClientResponseFlux = model.doChatByStreamByUserId(conversation);
//
//        chatClientResponseFlux.subscribe(chunk -> {
//                    String text = Optional.ofNullable(chunk.getResult())
//                            .map(r -> r.getOutput())
//                            .map(o -> o.getText())
//                            .orElse(null);
//
//                    if (text == null) {
//                        return;
//                    }
//
//                    try {
//                        if (chunk.hasFinishReasons(Set.of("returnDirect"))){
//                            emitter.send(text);
//                        } else if (chunk.hasFinishReasons(Set.of("stop"))){
//                            ChatResponse chatRes = new ChatResponse();
//                            chatRes.setContentData(text);
//                            chatRes.setIsDone(true);
//                            emitter.send(chatRes);
//                        } else{
//                            ChatResponse chatResponse = new ChatResponse();
//                            chatResponse.setContentData(text);
//                            emitter.send(chatResponse);
//                        }
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                    }
//                },
//                emitter::completeWithError,
//                // 处理完成
//                emitter::complete)
//
//        ;
//        return emitter;

//
//        ChatResponse ChatResponse = new ChatResponse();
//        chatClientResponseFlux.subscribe(chunk -> {
//                    if (!chunk.getResult().getMetadata().getFinishReason().isEmpty()){
//                      ChatResponse.setIsDone(true);
//                    }
//                    try {
//                        if (chunk.getResult().getMetadata().getFinishReason().equals("returnDirect")){
//                            emitter.send(chunk.getResult().getOutput().getText());
//                        }else {
//                            ChatResponse.setContentData(chunk.getResult().getOutput().getText());
//                            emitter.send(ChatResponse);
//                        }
//
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                    }
//                },
//                emitter::completeWithError,
//                // 处理完成
//                emitter::complete)
//
//        ;
//        return emitter;

//    }






//    private final ChatClient chatClient;

    // 请求方式和路径不要改动，将来要与前端联调
//    @RequestMapping("/chat")
//    public String chat(@RequestParam(defaultValue = "讲个笑话") String prompt) {
//        return chatClient
//                .prompt(prompt) // 传入user提示词
//                .call() // 同步请求，会等待AI全部输出完才返回结果
//                .content(); //返回响应内容
//    }

    // 注意看返回值，是Flux<String>，也就是流式结果，另外需要设定响应类型和编码，不然前端会乱码
//    @RequestMapping(value = "/chat", produces = "text/html;charset=UTF-8")
//    public Flux<String> chat(@RequestParam(defaultValue = "讲个笑话") String msg) {
//        return chatClient
//                //设置提示词
//                .prompt(msg) // 传入user提示词
//                .stream() // 流式调用
//                .content();  //返回文本
//    }




}